package com.demo.mangyThread;

import java.util.concurrent.*;

public class ThreadPool {




    //自定义拒绝策略
    public static class CustomIgnorePolicy
            implements RejectedExecutionHandler
    {
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e)
        {
            // 可做日志记录等
            System.out.println("自定义线程拒绝策略:"+r+"---"+e.getTaskCount());
        }
    }

    public static void main(String[] args) {
        RejectedExecutionHandler customIgnorePolicy = new CustomIgnorePolicy();
        //   ExecutorService pool = Executors.newFixedThreadPool(5);//固定数量线程池大小
     //   ExecutorService pool = Executors.newSingleThreadExecutor();//一个固定的线程池大小
     //   ExecutorService pool = Executors.newCachedThreadPool();//可伸缩的 遇强则强,遇弱则弱
        ExecutorService pool=new ThreadPoolExecutor(2,5,3,TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                customIgnorePolicy);//自定义拒绝策略
               // new ThreadPoolExecutor.AbortPolicy()); CallerRunsPolicy()用调用者所在的线程来执行任务
        // 该方法可以使子线程获取到主线程中的数据
      //  InheritableThreadLocal<Object> inheritableThreadLocal = new InheritableThreadLocal<>();
        // 解决线程池之前数据传递问题
       // TransmittableThreadLocal

        try{
            for(int i=1;i<=15;i++){
              pool.execute(new RunThread());
            }
        }catch (Exception e){

        }finally {
            pool.shutdown();
        }
        System.out.println("0000000000");

    }
    /***
     * 线程数七大参数说明
     * corePoolSize: 核心线程数{一直存在,除非（allowCoreThreadTimeOut）},线程池创建好，准备就绪
     * maximumPoolSize: 最大线程数 ，控制资源
     * keepAliveTime： 存活时间，如果当前的线程数量大于core数量，释放空闲的线程（maximumPoolSize-corePoolSize），只要线程空闲大于
     * 指定的存活时间，就会被释放
     * unit: 时间单位
     * BlockingQueue：阻塞队列，如果任务很多，就会将目前多的任务放在队列里面。只要有线程空闲，就会去队列里面取出新的任务继续执行
     * threadFactory: 现成的创建工程
     * handle:如果队列满了，按照指定的拒绝策略拒绝执行任务
     *
     *
     *
     *
     *
     */

}
